// $insert class.ih
#include "parser.ih"

// The FIRST element of SR arrays shown below uses `d_type', defining the
// state's type, and `d_lastIdx' containing the last element's index. If
// d_lastIdx contains the REQ_TOKEN bitflag (see below) then the state needs
// a token: if in this state d_token_ is _UNDETERMINED_, nextToken() will be
// called

// The LAST element of SR arrays uses `d_token' containing the last retrieved
// token to speed up the (linear) seach.  Except for the first element of SR
// arrays, the field `d_action' is used to determine what to do next. If
// positive, it represents the next state (used with SHIFT); if zero, it
// indicates `ACCEPT', if negative, -d_action represents the number of the
// rule to reduce to.

// `lookup()' tries to find d_token_ in the current SR array. If it fails, and
// there is no default reduction UNEXPECTED_TOKEN_ is thrown, which is then
// caught by the error-recovery function.

// The error-recovery function will pop elements off the stack until a state
// having bit flag ERR_ITEM is found. This state has a transition on _error_
// which is applied. In this _error_ state, while the current token is not a
// proper continuation, new tokens are obtained by nextToken(). If such a
// token is found, error recovery is successful and the token is
// handled according to the error state's SR table and parsing continues.
// During error recovery semantic actions are ignored.

// A state flagged with the DEF_RED flag will perform a default
// reduction if no other continuations are available for the current token.

// The ACCEPT STATE never shows a default reduction: when it is reached the
// parser returns ACCEPT(). During the grammar
// analysis phase a default reduction may have been defined, but it is
// removed during the state-definition phase.

// So:
//      s_x[] = 
//      {
//                  [_field_1_]         [_field_2_]
//
// First element:   {state-type,        idx of last element},
// Other elements:  {required token,    action to perform},
//                                      ( < 0: reduce, 
//                                          0: ACCEPT,
//                                        > 0: next state)
// Last element:    {set to d_token_,    action to perform}
//      }

// When the --thread-safe option is specified, all static data are defined as
// const. If --thread-safe is not provided, the state-tables are not defined
// as const, since the lookup() function below will modify them

// $insert debugincludes
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <iomanip>

namespace // anonymous
{
    char const author[] = "Frank B. Brokken (f.b.brokken@rug.nl)";

    enum 
    {
        STACK_EXPANSION = 5     // size to expand the state-stack with when
                                // full
    };

    enum ReservedTokens
    {
        PARSE_ACCEPT     = 0,   // `ACCEPT' TRANSITION
        _UNDETERMINED_   = -2,
        _EOF_            = -1,
        _error_          = 256
    };
    enum StateType       // modify statetype/data.cc when this enum changes
    {
        NORMAL,
        ERR_ITEM,
        REQ_TOKEN,
        ERR_REQ,    // ERR_ITEM | REQ_TOKEN
        DEF_RED,    // state having default reduction
        ERR_DEF,    // ERR_ITEM | DEF_RED
        REQ_DEF,    // REQ_TOKEN | DEF_RED
        ERR_REQ_DEF // ERR_ITEM | REQ_TOKEN | DEF_RED
    };    
    struct PI_     // Production Info
    {
        size_t d_nonTerm; // identification number of this production's
                            // non-terminal 
        size_t d_size;    // number of elements in this production 
    };

    struct SR_     // Shift Reduce info, see its description above
    {
        union
        {
            int _field_1_;      // initializer, allowing initializations 
                                // of the SR s_[] arrays
            int d_type;
            int d_token;
        };
        union
        {
            int _field_2_;

            int d_lastIdx;          // if negative, the state uses SHIFT
            int d_action;           // may be negative (reduce), 
                                    // postive (shift), or 0 (accept)
            size_t d_errorState;    // used with Error states
        };
    };

    // $insert staticdata
    
// Productions Info Records:
PI_ const s_productionInfo[] = 
{
     {0, 0}, // not used: reduction values are negative
     {287, 3}, // 1: input (SECTION_DELIMITER) ->  opt_directives SECTION_DELIMITER rules
     {290, 1}, // 2: identifier (IDENTIFIER) ->  IDENTIFIER
     {291, 0}, // 3: _sc_name ->  <empty>
     {292, 2}, // 4: _start_condition_type (INCL_START_CONDITION) ->  INCL_START_CONDITION _sc_name
     {292, 2}, // 5: _start_condition_type (EXCL_START_CONDITION) ->  EXCL_START_CONDITION _sc_name
     {293, 2}, // 6: _start_condition_names ->  _start_condition_names identifier
     {293, 1}, // 7: _start_condition_names ->  identifier
     {294, 2}, // 8: _start_condition_directive ->  _start_condition_type _start_condition_names
     {295, 1}, // 9: _name_def ->  identifier
     {296, 2}, // 10: _name_definition (STRING) ->  _name_def STRING
     {297, 1}, // 11: _directive ->  option
     {297, 1}, // 12: _directive ->  _start_condition_directive
     {297, 1}, // 13: _directive ->  _name_definition
     {297, 1}, // 14: _directive (_error_) ->  _error_
     {297, 0}, // 15: _directive ->  <empty>
     {299, 2}, // 16: _directive_line ('\x0a') ->  _directive '\x0a'
     {288, 2}, // 17: opt_directives ->  opt_directives _directive_line
     {288, 0}, // 18: opt_directives ->  <empty>
     {300, 1}, // 19: _inputinterface (INPUTINTERFACE) ->  INPUTINTERFACE
     {301, 1}, // 20: _inputimplementation (INPUTIMPLEMENTATION) ->  INPUTIMPLEMENTATION
     {302, 1}, // 21: _classname (CLASSNAME) ->  CLASSNAME
     {303, 1}, // 22: _lexfunctionname (LEXFUNCTIONNAME) ->  LEXFUNCTIONNAME
     {304, 1}, // 23: _baseclassheader (BASECLASSHEADER) ->  BASECLASSHEADER
     {305, 1}, // 24: _classheader (CLASSHEADER) ->  CLASSHEADER
     {306, 1}, // 25: _implementationheader (IMPLEMENTATIONHEADER) ->  IMPLEMENTATIONHEADER
     {307, 1}, // 26: _lexsource (LEXSOURCE) ->  LEXSOURCE
     {308, 1}, // 27: _skeleton_directory (SKELETON_DIRECTORY) ->  SKELETON_DIRECTORY
     {309, 1}, // 28: _namespace (NAMESPACE) ->  NAMESPACE
     {310, 1}, // 29: _stringOrIdent (STRING) ->  STRING
     {310, 1}, // 30: _stringOrIdent (IDENTIFIER) ->  IDENTIFIER
     {311, 1}, // 31: _opt_comma (',') ->  ','
     {311, 0}, // 32: _opt_comma ->  <empty>
     {312, 1}, // 33: _debugname (IDENTIFIER) ->  IDENTIFIER
     {313, 3}, // 34: _debugnamelist ->  _debugnamelist _opt_comma _debugname
     {313, 1}, // 35: _debugnamelist ->  _debugname
     {314, 0}, // 36: _m_debugnamelist ->  <empty>
     {315, 3}, // 37: _opt_debugnamelist ('=') ->  _m_debugnamelist '=' _debugnamelist
     {315, 0}, // 38: _opt_debugnamelist ->  <empty>
     {316, 1}, // 39: _firststep (DECIMAL) ->  DECIMAL
     {317, 0}, // 40: _opt_laststep ->  <empty>
     {317, 1}, // 41: _opt_laststep (DECIMAL) ->  DECIMAL
     {318, 0}, // 42: _m_debugsteps ->  <empty>
     {319, 4}, // 43: _opt_steprange ('=') ->  _m_debugsteps '=' _firststep _opt_laststep
     {319, 0}, // 44: _opt_steprange ->  <empty>
     {298, 3}, // 45: option ('=') ->  _inputinterface '=' _stringOrIdent
     {298, 3}, // 46: option ('=') ->  _inputimplementation '=' _stringOrIdent
     {298, 3}, // 47: option ('=') ->  _classname '=' _stringOrIdent
     {298, 3}, // 48: option ('=') ->  _lexfunctionname '=' _stringOrIdent
     {298, 3}, // 49: option ('=') ->  _baseclassheader '=' _stringOrIdent
     {298, 3}, // 50: option ('=') ->  _classheader '=' _stringOrIdent
     {298, 3}, // 51: option ('=') ->  _implementationheader '=' _stringOrIdent
     {298, 3}, // 52: option ('=') ->  _lexsource '=' _stringOrIdent
     {298, 3}, // 53: option ('=') ->  _skeleton_directory '=' _stringOrIdent
     {298, 3}, // 54: option ('=') ->  _namespace '=' _stringOrIdent
     {298, 1}, // 55: option (INTERACTIVE) ->  INTERACTIVE
     {298, 2}, // 56: option (DEBUG) ->  DEBUG _opt_debugnamelist
     {298, 2}, // 57: option (DEBUG_STEPS) ->  DEBUG_STEPS _opt_steprange
     {298, 1}, // 58: option (NOLINES) ->  NOLINES
     {320, 3}, // 59: _miniscanner_list (',') ->  _miniscanner_list ',' identifier
     {320, 1}, // 60: _miniscanner_list ->  identifier
     {321, 1}, // 61: _miniscanner_specs ('*') ->  '*'
     {321, 1}, // 62: _miniscanner_specs ->  _miniscanner_list
     {322, 3}, // 63: _miniscanner ('<') ->  '<' _miniscanner_specs '>'
     {323, 1}, // 64: _combi_chars (STRING) ->  STRING
     {323, 1}, // 65: _combi_chars (DECIMAL) ->  DECIMAL
     {323, 1}, // 66: _combi_chars (ESCAPE_SEQUENCE) ->  ESCAPE_SEQUENCE
     {323, 1}, // 67: _combi_chars ->  identifier
     {323, 1}, // 68: _combi_chars (CHAR) ->  CHAR
     {323, 1}, // 69: _combi_chars ('.') ->  '.'
     {323, 1}, // 70: _combi_chars (',') ->  ','
     {323, 1}, // 71: _combi_chars ('^') ->  '^'
     {323, 1}, // 72: _combi_chars ('$') ->  '$'
     {323, 1}, // 73: _combi_chars ('=') ->  '='
     {323, 1}, // 74: _combi_chars ('-') ->  '-'
     {323, 1}, // 75: _combi_chars (''') ->  '''
     {324, 1}, // 76: _decimal (DECIMAL) ->  DECIMAL
     {325, 1}, // 77: _interval (DECIMAL) ->  DECIMAL
     {325, 3}, // 78: _interval (',') ->  _decimal ',' DECIMAL
     {325, 2}, // 79: _interval (',') ->  _decimal ','
     {326, 1}, // 80: _quantifier ('*') ->  '*'
     {326, 1}, // 81: _quantifier ('+') ->  '+'
     {326, 1}, // 82: _quantifier ('?') ->  '?'
     {326, 3}, // 83: _quantifier ('{') ->  '{' _interval '}'
     {327, 0}, // 84: _m_contents ->  <empty>
     {328, 2}, // 85: _cc_start (CC_START) ->  CC_START _m_contents
     {329, 2}, // 86: _cc_negated (CC_NEGATED) ->  CC_NEGATED _m_contents
     {330, 1}, // 87: _cc_end (']') ->  ']'
     {331, 1}, // 88: _cc_char ('/') ->  '/'
     {331, 1}, // 89: _cc_char ('|') ->  '|'
     {331, 1}, // 90: _cc_char ('(') ->  '('
     {331, 1}, // 91: _cc_char (')') ->  ')'
     {331, 1}, // 92: _cc_char ('*') ->  '*'
     {331, 1}, // 93: _cc_char ('+') ->  '+'
     {331, 1}, // 94: _cc_char ('?') ->  '?'
     {331, 1}, // 95: _cc_char ('{') ->  '{'
     {331, 1}, // 96: _cc_char ('}') ->  '}'
     {331, 1}, // 97: _cc_char ('<') ->  '<'
     {331, 1}, // 98: _cc_char ('>') ->  '>'
     {331, 1}, // 99: _cc_char ('[') ->  '['
     {332, 1}, // 100: _cc_element ->  _combi_chars
     {332, 1}, // 101: _cc_element (PREDEFINED_CLASS) ->  PREDEFINED_CLASS
     {332, 1}, // 102: _cc_element ->  _cc_char
     {333, 2}, // 103: _cc_contents ->  _cc_contents _cc_element
     {333, 1}, // 104: _cc_contents ->  _cc_element
     {334, 3}, // 105: _cc_set ->  _cc_start _cc_contents _cc_end
     {334, 3}, // 106: _cc_set ->  _cc_negated _cc_contents _cc_end
     {335, 3}, // 107: _characterclass (CC_PLUS) ->  _characterclass CC_PLUS _characterclass
     {335, 3}, // 108: _characterclass (CC_MINUS) ->  _characterclass CC_MINUS _characterclass
     {335, 1}, // 109: _characterclass ->  _cc_set
     {336, 1}, // 110: _simple_regex ->  _combi_chars
     {336, 2}, // 111: _simple_regex (CHAR) ->  _simple_regex _simple_regex
     {336, 3}, // 112: _simple_regex ('|') ->  _simple_regex '|' _simple_regex
     {336, 3}, // 113: _simple_regex ('(') ->  '(' _simple_regex ')'
     {336, 2}, // 114: _simple_regex ->  _simple_regex _quantifier
     {336, 1}, // 115: _simple_regex ->  _characterclass
     {337, 1}, // 116: _p_regex ->  _simple_regex
     {338, 1}, // 117: _regex ->  _p_regex
     {338, 3}, // 118: _regex ('/') ->  _p_regex '/' _p_regex
     {339, 2}, // 119: _optMs_regex ->  _miniscanner _regex
     {339, 1}, // 120: _optMs_regex ->  _regex
     {340, 3}, // 121: _optMs_regex_list (ORNL) ->  _optMs_regex_list ORNL _optMs_regex_list
     {340, 1}, // 122: _optMs_regex_list ->  _optMs_regex
     {341, 1}, // 123: _block (BLOCK) ->  BLOCK
     {342, 3}, // 124: _regex_list (ORNL) ->  _regex_list ORNL _regex_list
     {342, 1}, // 125: _regex_list ->  _regex
     {343, 1}, // 126: _eof_pattern (EOF_PATTERN) ->  EOF_PATTERN
     {343, 2}, // 127: _eof_pattern (EOF_PATTERN) ->  EOF_PATTERN _block
     {344, 0}, // 128: _msBlock_rule_def ->  <empty>
     {344, 1}, // 129: _msBlock_rule_def ->  _regex_list
     {344, 2}, // 130: _msBlock_rule_def ->  _regex_list _block
     {344, 1}, // 131: _msBlock_rule_def ->  _eof_pattern
     {345, 2}, // 132: _msBlock_rule ('\x0a') ->  _msBlock_rule_def '\x0a'
     {346, 2}, // 133: _msBlock_rules ->  _msBlock_rules _msBlock_rule
     {346, 0}, // 134: _msBlock_rules ->  <empty>
     {347, 5}, // 135: _msBlock ('{') ->  _miniscanner '{' _msBlock_rules _msBlock_rule_def '}'
     {348, 0}, // 136: _rule_def ->  <empty>
     {348, 1}, // 137: _rule_def (_error_) ->  _error_
     {348, 1}, // 138: _rule_def ->  _optMs_regex_list
     {348, 2}, // 139: _rule_def ->  _optMs_regex_list _block
     {348, 1}, // 140: _rule_def ->  _msBlock
     {348, 1}, // 141: _rule_def ->  _eof_pattern
     {349, 2}, // 142: _rule ('\x0a') ->  _rule_def '\x0a'
     {289, 2}, // 143: rules ->  rules _rule
     {289, 0}, // 144: rules ->  <empty>
     {350, 1}, // 145: input_$ ->  input
};

// State info and SR_ transitions for each state.


SR_ s_0[] =
{
    { { DEF_RED}, {   3} },                  
    { {     287}, {   1} }, // input         
    { {     288}, {   2} }, // opt_directives
    { {       0}, { -18} },                  
};

SR_ s_1[] =
{
    { { REQ_TOKEN}, {            2} }, 
    { {     _EOF_}, { PARSE_ACCEPT} }, 
    { {         0}, {            0} }, 
};

SR_ s_2[] =
{
    { { ERR_REQ_DEF}, {  38} },                              
    { {         259}, {   3} }, // SECTION_DELIMITER         
    { {         299}, {   4} }, // _directive_line           
    { {         297}, {   5} }, // _directive                
    { {         298}, {   6} }, // option                    
    { {         294}, {   7} }, // _start_condition_directive
    { {         296}, {   8} }, // _name_definition          
    { {     _error_}, {   9} }, // _error_                   
    { {         300}, {  10} }, // _inputinterface           
    { {         301}, {  11} }, // _inputimplementation      
    { {         302}, {  12} }, // _classname                
    { {         303}, {  13} }, // _lexfunctionname          
    { {         304}, {  14} }, // _baseclassheader          
    { {         305}, {  15} }, // _classheader              
    { {         306}, {  16} }, // _implementationheader     
    { {         307}, {  17} }, // _lexsource                
    { {         308}, {  18} }, // _skeleton_directory       
    { {         309}, {  19} }, // _namespace                
    { {         268}, {  20} }, // INTERACTIVE               
    { {         263}, {  21} }, // DEBUG                     
    { {         264}, {  22} }, // DEBUG_STEPS               
    { {         272}, {  23} }, // NOLINES                   
    { {         292}, {  24} }, // _start_condition_type     
    { {         295}, {  25} }, // _name_def                 
    { {         267}, {  26} }, // INPUTINTERFACE            
    { {         266}, {  27} }, // INPUTIMPLEMENTATION       
    { {         262}, {  28} }, // CLASSNAME                 
    { {         269}, {  29} }, // LEXFUNCTIONNAME           
    { {         260}, {  30} }, // BASECLASSHEADER           
    { {         261}, {  31} }, // CLASSHEADER               
    { {         265}, {  32} }, // IMPLEMENTATIONHEADER      
    { {         270}, {  33} }, // LEXSOURCE                 
    { {         273}, {  34} }, // SKELETON_DIRECTORY        
    { {         271}, {  35} }, // NAMESPACE                 
    { {         258}, {  36} }, // INCL_START_CONDITION      
    { {         257}, {  37} }, // EXCL_START_CONDITION      
    { {         290}, {  38} }, // identifier                
    { {         275}, {  39} }, // IDENTIFIER                
    { {           0}, { -15} },                              
};

SR_ s_3[] =
{
    { { DEF_RED}, {    2} },         
    { {     289}, {   40} }, // rules
    { {       0}, { -144} },         
};

SR_ s_4[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -17} }, 
};

SR_ s_5[] =
{
    { { REQ_TOKEN}, {  2} },          
    { {        10}, { 41} }, // '\x0a'
    { {         0}, {  0} },          
};

SR_ s_6[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -11} }, 
};

SR_ s_7[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -12} }, 
};

SR_ s_8[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -13} }, 
};

SR_ s_9[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -14} }, 
};

SR_ s_10[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 42} }, // '='
    { {         0}, {  0} },       
};

SR_ s_11[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 43} }, // '='
    { {         0}, {  0} },       
};

SR_ s_12[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 44} }, // '='
    { {         0}, {  0} },       
};

SR_ s_13[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 45} }, // '='
    { {         0}, {  0} },       
};

SR_ s_14[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 46} }, // '='
    { {         0}, {  0} },       
};

SR_ s_15[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 47} }, // '='
    { {         0}, {  0} },       
};

SR_ s_16[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 48} }, // '='
    { {         0}, {  0} },       
};

SR_ s_17[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 49} }, // '='
    { {         0}, {  0} },       
};

SR_ s_18[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 50} }, // '='
    { {         0}, {  0} },       
};

SR_ s_19[] =
{
    { { REQ_TOKEN}, {  2} },       
    { {        61}, { 51} }, // '='
    { {         0}, {  0} },       
};

SR_ s_20[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -55} }, 
};

SR_ s_21[] =
{
    { { REQ_DEF}, {   4} },                      
    { {     315}, {  52} }, // _opt_debugnamelist
    { {     314}, {  53} }, // _m_debugnamelist  
    { {      10}, { -38} }, // '\x0a'            
    { {       0}, { -36} },                      
};

SR_ s_22[] =
{
    { { REQ_DEF}, {   4} },                  
    { {     319}, {  54} }, // _opt_steprange
    { {     318}, {  55} }, // _m_debugsteps 
    { {      10}, { -44} }, // '\x0a'        
    { {       0}, { -42} },                  
};

SR_ s_23[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -58} }, 
};

SR_ s_24[] =
{
    { { REQ_TOKEN}, {  4} },                          
    { {       293}, { 56} }, // _start_condition_names
    { {       290}, { 57} }, // identifier            
    { {       275}, { 39} }, // IDENTIFIER            
    { {         0}, {  0} },                          
};

SR_ s_25[] =
{
    { { REQ_TOKEN}, {  2} },          
    { {       277}, { 58} }, // STRING
    { {         0}, {  0} },          
};

SR_ s_26[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -19} }, 
};

SR_ s_27[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -20} }, 
};

SR_ s_28[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -21} }, 
};

SR_ s_29[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -22} }, 
};

SR_ s_30[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -23} }, 
};

SR_ s_31[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -24} }, 
};

SR_ s_32[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -25} }, 
};

SR_ s_33[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -26} }, 
};

SR_ s_34[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -27} }, 
};

SR_ s_35[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -28} }, 
};

SR_ s_36[] =
{
    { { DEF_RED}, {  2} },            
    { {     291}, { 59} }, // _sc_name
    { {       0}, { -3} },            
};

SR_ s_37[] =
{
    { { DEF_RED}, {  2} },            
    { {     291}, { 60} }, // _sc_name
    { {       0}, { -3} },            
};

SR_ s_38[] =
{
    { { DEF_RED}, {  1} }, 
    { {       0}, { -9} }, 
};

SR_ s_39[] =
{
    { { DEF_RED}, {  1} }, 
    { {       0}, { -2} }, 
};

SR_ s_40[] =
{
    { { ERR_REQ_DEF}, {   36} },                     
    { {         349}, {   61} }, // _rule            
    { {         348}, {   62} }, // _rule_def        
    { {     _error_}, {   63} }, // _error_          
    { {         340}, {   64} }, // _optMs_regex_list
    { {         347}, {   65} }, // _msBlock         
    { {         343}, {   66} }, // _eof_pattern     
    { {         339}, {   67} }, // _optMs_regex     
    { {         322}, {   68} }, // _miniscanner     
    { {         276}, {   69} }, // EOF_PATTERN      
    { {         338}, {   70} }, // _regex           
    { {          60}, {   71} }, // '<'              
    { {         337}, {   72} }, // _p_regex         
    { {         336}, {   73} }, // _simple_regex    
    { {         323}, {   74} }, // _combi_chars     
    { {          40}, {   75} }, // '('              
    { {         335}, {   76} }, // _characterclass  
    { {         277}, {   77} }, // STRING           
    { {         278}, {   78} }, // DECIMAL          
    { {         279}, {   79} }, // ESCAPE_SEQUENCE  
    { {         290}, {   80} }, // identifier       
    { {         284}, {   81} }, // CHAR             
    { {          46}, {   82} }, // '.'              
    { {          44}, {   83} }, // ','              
    { {          94}, {   84} }, // '^'              
    { {          36}, {   85} }, // '$'              
    { {          61}, {   86} }, // '='              
    { {          45}, {   87} }, // '-'              
    { {          39}, {   88} }, // '''              
    { {         334}, {   89} }, // _cc_set          
    { {         275}, {   39} }, // IDENTIFIER       
    { {         328}, {   90} }, // _cc_start        
    { {         329}, {   91} }, // _cc_negated      
    { {         280}, {   92} }, // CC_START         
    { {         281}, {   93} }, // CC_NEGATED       
    { {       _EOF_}, {   -1} }, // _EOF_            
    { {           0}, { -136} },                     
};

SR_ s_41[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -16} }, 
};

SR_ s_42[] =
{
    { { REQ_TOKEN}, {  4} },                  
    { {       310}, { 94} }, // _stringOrIdent
    { {       277}, { 95} }, // STRING        
    { {       275}, { 96} }, // IDENTIFIER    
    { {         0}, {  0} },                  
};

SR_ s_43[] =
{
    { { REQ_TOKEN}, {  4} },                  
    { {       310}, { 97} }, // _stringOrIdent
    { {       277}, { 95} }, // STRING        
    { {       275}, { 96} }, // IDENTIFIER    
    { {         0}, {  0} },                  
};

SR_ s_44[] =
{
    { { REQ_TOKEN}, {  4} },                  
    { {       310}, { 98} }, // _stringOrIdent
    { {       277}, { 95} }, // STRING        
    { {       275}, { 96} }, // IDENTIFIER    
    { {         0}, {  0} },                  
};

SR_ s_45[] =
{
    { { REQ_TOKEN}, {  4} },                  
    { {       310}, { 99} }, // _stringOrIdent
    { {       277}, { 95} }, // STRING        
    { {       275}, { 96} }, // IDENTIFIER    
    { {         0}, {  0} },                  
};

SR_ s_46[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       310}, { 100} }, // _stringOrIdent
    { {       277}, {  95} }, // STRING        
    { {       275}, {  96} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_47[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       310}, { 101} }, // _stringOrIdent
    { {       277}, {  95} }, // STRING        
    { {       275}, {  96} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_48[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       310}, { 102} }, // _stringOrIdent
    { {       277}, {  95} }, // STRING        
    { {       275}, {  96} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_49[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       310}, { 103} }, // _stringOrIdent
    { {       277}, {  95} }, // STRING        
    { {       275}, {  96} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_50[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       310}, { 104} }, // _stringOrIdent
    { {       277}, {  95} }, // STRING        
    { {       275}, {  96} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_51[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       310}, { 105} }, // _stringOrIdent
    { {       277}, {  95} }, // STRING        
    { {       275}, {  96} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_52[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -56} }, 
};

SR_ s_53[] =
{
    { { REQ_TOKEN}, {   2} },       
    { {        61}, { 106} }, // '='
    { {         0}, {   0} },       
};

SR_ s_54[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -57} }, 
};

SR_ s_55[] =
{
    { { REQ_TOKEN}, {   2} },       
    { {        61}, { 107} }, // '='
    { {         0}, {   0} },       
};

SR_ s_56[] =
{
    { { REQ_DEF}, {   3} },              
    { {     290}, { 108} }, // identifier
    { {     275}, {  39} }, // IDENTIFIER
    { {       0}, {  -8} },              
};

SR_ s_57[] =
{
    { { DEF_RED}, {  1} }, 
    { {       0}, { -7} }, 
};

SR_ s_58[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -10} }, 
};

SR_ s_59[] =
{
    { { DEF_RED}, {  1} }, 
    { {       0}, { -4} }, 
};

SR_ s_60[] =
{
    { { DEF_RED}, {  1} }, 
    { {       0}, { -5} }, 
};

SR_ s_61[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -143} }, 
};

SR_ s_62[] =
{
    { { REQ_TOKEN}, {   2} },          
    { {        10}, { 109} }, // '\x0a'
    { {         0}, {   0} },          
};

SR_ s_63[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -137} }, 
};

SR_ s_64[] =
{
    { { REQ_DEF}, {    4} },          
    { {     341}, {  110} }, // _block
    { {     283}, {  111} }, // ORNL  
    { {     274}, {  112} }, // BLOCK 
    { {       0}, { -138} },          
};

SR_ s_65[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -140} }, 
};

SR_ s_66[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -141} }, 
};

SR_ s_67[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -122} }, 
};

SR_ s_68[] =
{
    { { REQ_TOKEN}, {  26} },                   
    { {       123}, { 113} }, // '{'            
    { {       338}, { 114} }, // _regex         
    { {       337}, {  72} }, // _p_regex       
    { {       336}, {  73} }, // _simple_regex  
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_69[] =
{
    { { REQ_DEF}, {    3} },          
    { {     341}, {  115} }, // _block
    { {     274}, {  112} }, // BLOCK 
    { {       0}, { -126} },          
};

SR_ s_70[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -120} }, 
};

SR_ s_71[] =
{
    { { REQ_TOKEN}, {   6} },                      
    { {       321}, { 116} }, // _miniscanner_specs
    { {        42}, { 117} }, // '*'               
    { {       320}, { 118} }, // _miniscanner_list 
    { {       290}, { 119} }, // identifier        
    { {       275}, {  39} }, // IDENTIFIER        
    { {         0}, {   0} },                      
};

SR_ s_72[] =
{
    { { REQ_DEF}, {    2} },       
    { {      47}, {  120} }, // '/'
    { {       0}, { -117} },       
};

SR_ s_73[] =
{
    { { REQ_DEF}, {   29} },                   
    { {     336}, {  121} }, // _simple_regex  
    { {     124}, {  122} }, // '|'            
    { {     326}, {  123} }, // _quantifier    
    { {     323}, {   74} }, // _combi_chars   
    { {      40}, {   75} }, // '('            
    { {     335}, {   76} }, // _characterclass
    { {      42}, {  124} }, // '*'            
    { {      43}, {  125} }, // '+'            
    { {      63}, {  126} }, // '?'            
    { {     123}, {  127} }, // '{'            
    { {     277}, {   77} }, // STRING         
    { {     278}, {   78} }, // DECIMAL        
    { {     279}, {   79} }, // ESCAPE_SEQUENCE
    { {     290}, {   80} }, // identifier     
    { {     284}, {   81} }, // CHAR           
    { {      46}, {   82} }, // '.'            
    { {      44}, {   83} }, // ','            
    { {      94}, {   84} }, // '^'            
    { {      36}, {   85} }, // '$'            
    { {      61}, {   86} }, // '='            
    { {      45}, {   87} }, // '-'            
    { {      39}, {   88} }, // '''            
    { {     334}, {   89} }, // _cc_set        
    { {     275}, {   39} }, // IDENTIFIER     
    { {     328}, {   90} }, // _cc_start      
    { {     329}, {   91} }, // _cc_negated    
    { {     280}, {   92} }, // CC_START       
    { {     281}, {   93} }, // CC_NEGATED     
    { {       0}, { -116} },                   
};

SR_ s_74[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -110} }, 
};

SR_ s_75[] =
{
    { { REQ_TOKEN}, {  23} },                   
    { {       336}, { 128} }, // _simple_regex  
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_76[] =
{
    { { REQ_DEF}, {    3} },            
    { {     285}, {  129} }, // CC_PLUS 
    { {     286}, {  130} }, // CC_MINUS
    { {       0}, { -115} },            
};

SR_ s_77[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -64} }, 
};

SR_ s_78[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -65} }, 
};

SR_ s_79[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -66} }, 
};

SR_ s_80[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -67} }, 
};

SR_ s_81[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -68} }, 
};

SR_ s_82[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -69} }, 
};

SR_ s_83[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -70} }, 
};

SR_ s_84[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -71} }, 
};

SR_ s_85[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -72} }, 
};

SR_ s_86[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -73} }, 
};

SR_ s_87[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -74} }, 
};

SR_ s_88[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -75} }, 
};

SR_ s_89[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -109} }, 
};

SR_ s_90[] =
{
    { { REQ_TOKEN}, {  31} },                    
    { {       333}, { 131} }, // _cc_contents    
    { {       332}, { 132} }, // _cc_element     
    { {       323}, { 133} }, // _combi_chars    
    { {       282}, { 134} }, // PREDEFINED_CLASS
    { {       331}, { 135} }, // _cc_char        
    { {       277}, {  77} }, // STRING          
    { {       278}, {  78} }, // DECIMAL         
    { {       279}, {  79} }, // ESCAPE_SEQUENCE 
    { {       290}, {  80} }, // identifier      
    { {       284}, {  81} }, // CHAR            
    { {        46}, {  82} }, // '.'             
    { {        44}, {  83} }, // ','             
    { {        94}, {  84} }, // '^'             
    { {        36}, {  85} }, // '$'             
    { {        61}, {  86} }, // '='             
    { {        45}, {  87} }, // '-'             
    { {        39}, {  88} }, // '''             
    { {        47}, { 136} }, // '/'             
    { {       124}, { 137} }, // '|'             
    { {        40}, { 138} }, // '('             
    { {        41}, { 139} }, // ')'             
    { {        42}, { 140} }, // '*'             
    { {        43}, { 141} }, // '+'             
    { {        63}, { 142} }, // '?'             
    { {       123}, { 143} }, // '{'             
    { {       125}, { 144} }, // '}'             
    { {        60}, { 145} }, // '<'             
    { {        62}, { 146} }, // '>'             
    { {        91}, { 147} }, // '['             
    { {       275}, {  39} }, // IDENTIFIER      
    { {         0}, {   0} },                    
};

SR_ s_91[] =
{
    { { REQ_TOKEN}, {  31} },                    
    { {       333}, { 148} }, // _cc_contents    
    { {       332}, { 132} }, // _cc_element     
    { {       323}, { 133} }, // _combi_chars    
    { {       282}, { 134} }, // PREDEFINED_CLASS
    { {       331}, { 135} }, // _cc_char        
    { {       277}, {  77} }, // STRING          
    { {       278}, {  78} }, // DECIMAL         
    { {       279}, {  79} }, // ESCAPE_SEQUENCE 
    { {       290}, {  80} }, // identifier      
    { {       284}, {  81} }, // CHAR            
    { {        46}, {  82} }, // '.'             
    { {        44}, {  83} }, // ','             
    { {        94}, {  84} }, // '^'             
    { {        36}, {  85} }, // '$'             
    { {        61}, {  86} }, // '='             
    { {        45}, {  87} }, // '-'             
    { {        39}, {  88} }, // '''             
    { {        47}, { 136} }, // '/'             
    { {       124}, { 137} }, // '|'             
    { {        40}, { 138} }, // '('             
    { {        41}, { 139} }, // ')'             
    { {        42}, { 140} }, // '*'             
    { {        43}, { 141} }, // '+'             
    { {        63}, { 142} }, // '?'             
    { {       123}, { 143} }, // '{'             
    { {       125}, { 144} }, // '}'             
    { {        60}, { 145} }, // '<'             
    { {        62}, { 146} }, // '>'             
    { {        91}, { 147} }, // '['             
    { {       275}, {  39} }, // IDENTIFIER      
    { {         0}, {   0} },                    
};

SR_ s_92[] =
{
    { { DEF_RED}, {   2} },               
    { {     327}, { 149} }, // _m_contents
    { {       0}, { -84} },               
};

SR_ s_93[] =
{
    { { DEF_RED}, {   2} },               
    { {     327}, { 150} }, // _m_contents
    { {       0}, { -84} },               
};

SR_ s_94[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -45} }, 
};

SR_ s_95[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -29} }, 
};

SR_ s_96[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -30} }, 
};

SR_ s_97[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -46} }, 
};

SR_ s_98[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -47} }, 
};

SR_ s_99[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -48} }, 
};

SR_ s_100[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -49} }, 
};

SR_ s_101[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -50} }, 
};

SR_ s_102[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -51} }, 
};

SR_ s_103[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -52} }, 
};

SR_ s_104[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -53} }, 
};

SR_ s_105[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -54} }, 
};

SR_ s_106[] =
{
    { { REQ_TOKEN}, {   4} },                  
    { {       313}, { 151} }, // _debugnamelist
    { {       312}, { 152} }, // _debugname    
    { {       275}, { 153} }, // IDENTIFIER    
    { {         0}, {   0} },                  
};

SR_ s_107[] =
{
    { { REQ_TOKEN}, {   3} },              
    { {       316}, { 154} }, // _firststep
    { {       278}, { 155} }, // DECIMAL   
    { {         0}, {   0} },              
};

SR_ s_108[] =
{
    { { DEF_RED}, {  1} }, 
    { {       0}, { -6} }, 
};

SR_ s_109[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -142} }, 
};

SR_ s_110[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -139} }, 
};

SR_ s_111[] =
{
    { { REQ_TOKEN}, {  29} },                     
    { {       340}, { 156} }, // _optMs_regex_list
    { {       339}, {  67} }, // _optMs_regex     
    { {       322}, { 157} }, // _miniscanner     
    { {       338}, {  70} }, // _regex           
    { {        60}, {  71} }, // '<'              
    { {       337}, {  72} }, // _p_regex         
    { {       336}, {  73} }, // _simple_regex    
    { {       323}, {  74} }, // _combi_chars     
    { {        40}, {  75} }, // '('              
    { {       335}, {  76} }, // _characterclass  
    { {       277}, {  77} }, // STRING           
    { {       278}, {  78} }, // DECIMAL          
    { {       279}, {  79} }, // ESCAPE_SEQUENCE  
    { {       290}, {  80} }, // identifier       
    { {       284}, {  81} }, // CHAR             
    { {        46}, {  82} }, // '.'              
    { {        44}, {  83} }, // ','              
    { {        94}, {  84} }, // '^'              
    { {        36}, {  85} }, // '$'              
    { {        61}, {  86} }, // '='              
    { {        45}, {  87} }, // '-'              
    { {        39}, {  88} }, // '''              
    { {       334}, {  89} }, // _cc_set          
    { {       275}, {  39} }, // IDENTIFIER       
    { {       328}, {  90} }, // _cc_start        
    { {       329}, {  91} }, // _cc_negated      
    { {       280}, {  92} }, // CC_START         
    { {       281}, {  93} }, // CC_NEGATED       
    { {         0}, {   0} },                     
};

SR_ s_112[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -123} }, 
};

SR_ s_113[] =
{
    { { DEF_RED}, {    2} },                  
    { {     346}, {  158} }, // _msBlock_rules
    { {       0}, { -134} },                  
};

SR_ s_114[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -119} }, 
};

SR_ s_115[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -127} }, 
};

SR_ s_116[] =
{
    { { REQ_TOKEN}, {   2} },       
    { {        62}, { 159} }, // '>'
    { {         0}, {   0} },       
};

SR_ s_117[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -61} }, 
};

SR_ s_118[] =
{
    { { REQ_DEF}, {   2} },       
    { {      44}, { 160} }, // ','
    { {       0}, { -62} },       
};

SR_ s_119[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -60} }, 
};

SR_ s_120[] =
{
    { { REQ_TOKEN}, {  24} },                   
    { {       337}, { 161} }, // _p_regex       
    { {       336}, {  73} }, // _simple_regex  
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_121[] =
{
    { { REQ_DEF}, {    9} },                   
    { {     336}, {  121} }, // _simple_regex  
    { {     326}, {  123} }, // _quantifier    
    { {     323}, {   74} }, // _combi_chars   
    { {     335}, {   76} }, // _characterclass
    { {     290}, {   80} }, // identifier     
    { {     334}, {   89} }, // _cc_set        
    { {     328}, {   90} }, // _cc_start      
    { {     329}, {   91} }, // _cc_negated    
    { {       0}, { -111} },                   
};

SR_ s_122[] =
{
    { { REQ_TOKEN}, {  23} },                   
    { {       336}, { 162} }, // _simple_regex  
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_123[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -114} }, 
};

SR_ s_124[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -80} }, 
};

SR_ s_125[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -81} }, 
};

SR_ s_126[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -82} }, 
};

SR_ s_127[] =
{
    { { REQ_TOKEN}, {   4} },             
    { {       325}, { 163} }, // _interval
    { {       278}, { 164} }, // DECIMAL  
    { {       324}, { 165} }, // _decimal 
    { {         0}, {   0} },             
};

SR_ s_128[] =
{
    { { REQ_TOKEN}, {  30} },                   
    { {        41}, { 166} }, // ')'            
    { {       336}, { 121} }, // _simple_regex  
    { {       124}, { 122} }, // '|'            
    { {       326}, { 123} }, // _quantifier    
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {        42}, { 124} }, // '*'            
    { {        43}, { 125} }, // '+'            
    { {        63}, { 126} }, // '?'            
    { {       123}, { 127} }, // '{'            
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_129[] =
{
    { { REQ_TOKEN}, {   7} },                   
    { {       335}, { 167} }, // _characterclass
    { {       334}, {  89} }, // _cc_set        
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_130[] =
{
    { { REQ_TOKEN}, {   7} },                   
    { {       335}, { 168} }, // _characterclass
    { {       334}, {  89} }, // _cc_set        
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_131[] =
{
    { { REQ_TOKEN}, {  32} },                    
    { {       330}, { 169} }, // _cc_end         
    { {       332}, { 170} }, // _cc_element     
    { {        93}, { 171} }, // ']'             
    { {       323}, { 133} }, // _combi_chars    
    { {       282}, { 134} }, // PREDEFINED_CLASS
    { {       331}, { 135} }, // _cc_char        
    { {       277}, {  77} }, // STRING          
    { {       278}, {  78} }, // DECIMAL         
    { {       279}, {  79} }, // ESCAPE_SEQUENCE 
    { {       290}, {  80} }, // identifier      
    { {       284}, {  81} }, // CHAR            
    { {        46}, {  82} }, // '.'             
    { {        44}, {  83} }, // ','             
    { {        94}, {  84} }, // '^'             
    { {        36}, {  85} }, // '$'             
    { {        61}, {  86} }, // '='             
    { {        45}, {  87} }, // '-'             
    { {        39}, {  88} }, // '''             
    { {        47}, { 136} }, // '/'             
    { {       124}, { 137} }, // '|'             
    { {        40}, { 138} }, // '('             
    { {        41}, { 139} }, // ')'             
    { {        42}, { 140} }, // '*'             
    { {        43}, { 141} }, // '+'             
    { {        63}, { 142} }, // '?'             
    { {       123}, { 143} }, // '{'             
    { {       125}, { 144} }, // '}'             
    { {        60}, { 145} }, // '<'             
    { {        62}, { 146} }, // '>'             
    { {        91}, { 147} }, // '['             
    { {       275}, {  39} }, // IDENTIFIER      
    { {         0}, {   0} },                    
};

SR_ s_132[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -104} }, 
};

SR_ s_133[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -100} }, 
};

SR_ s_134[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -101} }, 
};

SR_ s_135[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -102} }, 
};

SR_ s_136[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -88} }, 
};

SR_ s_137[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -89} }, 
};

SR_ s_138[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -90} }, 
};

SR_ s_139[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -91} }, 
};

SR_ s_140[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -92} }, 
};

SR_ s_141[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -93} }, 
};

SR_ s_142[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -94} }, 
};

SR_ s_143[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -95} }, 
};

SR_ s_144[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -96} }, 
};

SR_ s_145[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -97} }, 
};

SR_ s_146[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -98} }, 
};

SR_ s_147[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -99} }, 
};

SR_ s_148[] =
{
    { { REQ_TOKEN}, {  32} },                    
    { {       330}, { 172} }, // _cc_end         
    { {       332}, { 170} }, // _cc_element     
    { {        93}, { 171} }, // ']'             
    { {       323}, { 133} }, // _combi_chars    
    { {       282}, { 134} }, // PREDEFINED_CLASS
    { {       331}, { 135} }, // _cc_char        
    { {       277}, {  77} }, // STRING          
    { {       278}, {  78} }, // DECIMAL         
    { {       279}, {  79} }, // ESCAPE_SEQUENCE 
    { {       290}, {  80} }, // identifier      
    { {       284}, {  81} }, // CHAR            
    { {        46}, {  82} }, // '.'             
    { {        44}, {  83} }, // ','             
    { {        94}, {  84} }, // '^'             
    { {        36}, {  85} }, // '$'             
    { {        61}, {  86} }, // '='             
    { {        45}, {  87} }, // '-'             
    { {        39}, {  88} }, // '''             
    { {        47}, { 136} }, // '/'             
    { {       124}, { 137} }, // '|'             
    { {        40}, { 138} }, // '('             
    { {        41}, { 139} }, // ')'             
    { {        42}, { 140} }, // '*'             
    { {        43}, { 141} }, // '+'             
    { {        63}, { 142} }, // '?'             
    { {       123}, { 143} }, // '{'             
    { {       125}, { 144} }, // '}'             
    { {        60}, { 145} }, // '<'             
    { {        62}, { 146} }, // '>'             
    { {        91}, { 147} }, // '['             
    { {       275}, {  39} }, // IDENTIFIER      
    { {         0}, {   0} },                    
};

SR_ s_149[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -85} }, 
};

SR_ s_150[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -86} }, 
};

SR_ s_151[] =
{
    { { REQ_DEF}, {   4} },              
    { {     311}, { 173} }, // _opt_comma
    { {      44}, { 174} }, // ','       
    { {      10}, { -37} }, // '\x0a'    
    { {       0}, { -32} },              
};

SR_ s_152[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -35} }, 
};

SR_ s_153[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -33} }, 
};

SR_ s_154[] =
{
    { { REQ_DEF}, {   3} },                 
    { {     317}, { 175} }, // _opt_laststep
    { {     278}, { 176} }, // DECIMAL      
    { {       0}, { -40} },                 
};

SR_ s_155[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -39} }, 
};

SR_ s_156[] =
{
    { { REQ_DEF}, {    1} }, 
    { {       0}, { -121} }, 
};

SR_ s_157[] =
{
    { { REQ_TOKEN}, {  25} },                   
    { {       338}, { 114} }, // _regex         
    { {       337}, {  72} }, // _p_regex       
    { {       336}, {  73} }, // _simple_regex  
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_158[] =
{
    { { REQ_DEF}, {   30} },                     
    { {     344}, {  177} }, // _msBlock_rule_def
    { {     345}, {  178} }, // _msBlock_rule    
    { {     342}, {  179} }, // _regex_list      
    { {     343}, {  180} }, // _eof_pattern     
    { {     338}, {  181} }, // _regex           
    { {     276}, {   69} }, // EOF_PATTERN      
    { {     337}, {   72} }, // _p_regex         
    { {     336}, {   73} }, // _simple_regex    
    { {     323}, {   74} }, // _combi_chars     
    { {      40}, {   75} }, // '('              
    { {     335}, {   76} }, // _characterclass  
    { {     277}, {   77} }, // STRING           
    { {     278}, {   78} }, // DECIMAL          
    { {     279}, {   79} }, // ESCAPE_SEQUENCE  
    { {     290}, {   80} }, // identifier       
    { {     284}, {   81} }, // CHAR             
    { {      46}, {   82} }, // '.'              
    { {      44}, {   83} }, // ','              
    { {      94}, {   84} }, // '^'              
    { {      36}, {   85} }, // '$'              
    { {      61}, {   86} }, // '='              
    { {      45}, {   87} }, // '-'              
    { {      39}, {   88} }, // '''              
    { {     334}, {   89} }, // _cc_set          
    { {     275}, {   39} }, // IDENTIFIER       
    { {     328}, {   90} }, // _cc_start        
    { {     329}, {   91} }, // _cc_negated      
    { {     280}, {   92} }, // CC_START         
    { {     281}, {   93} }, // CC_NEGATED       
    { {       0}, { -128} },                     
};

SR_ s_159[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -63} }, 
};

SR_ s_160[] =
{
    { { REQ_TOKEN}, {   3} },              
    { {       290}, { 182} }, // identifier
    { {       275}, {  39} }, // IDENTIFIER
    { {         0}, {   0} },              
};

SR_ s_161[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -118} }, 
};

SR_ s_162[] =
{
    { { REQ_DEF}, {   10} },                   
    { {     336}, {  121} }, // _simple_regex  
    { {     326}, {  123} }, // _quantifier    
    { {     323}, {   74} }, // _combi_chars   
    { {     335}, {   76} }, // _characterclass
    { {     290}, {   80} }, // identifier     
    { {     284}, {   81} }, // CHAR           
    { {     334}, {   89} }, // _cc_set        
    { {     328}, {   90} }, // _cc_start      
    { {     329}, {   91} }, // _cc_negated    
    { {       0}, { -112} },                   
};

SR_ s_163[] =
{
    { { REQ_TOKEN}, {   2} },       
    { {       125}, { 183} }, // '}'
    { {         0}, {   0} },       
};

SR_ s_164[] =
{
    { { REQ_DEF}, {   2} },       
    { {     125}, { -77} }, // '}'
    { {       0}, { -76} },       
};

SR_ s_165[] =
{
    { { REQ_TOKEN}, {   2} },       
    { {        44}, { 184} }, // ','
    { {         0}, {   0} },       
};

SR_ s_166[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -113} }, 
};

SR_ s_167[] =
{
    { { REQ_DEF}, {    1} }, 
    { {       0}, { -107} }, 
};

SR_ s_168[] =
{
    { { REQ_DEF}, {    1} }, 
    { {       0}, { -108} }, 
};

SR_ s_169[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -105} }, 
};

SR_ s_170[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -103} }, 
};

SR_ s_171[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -87} }, 
};

SR_ s_172[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -106} }, 
};

SR_ s_173[] =
{
    { { REQ_TOKEN}, {   3} },              
    { {       312}, { 185} }, // _debugname
    { {       275}, { 153} }, // IDENTIFIER
    { {         0}, {   0} },              
};

SR_ s_174[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -31} }, 
};

SR_ s_175[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -43} }, 
};

SR_ s_176[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -41} }, 
};

SR_ s_177[] =
{
    { { REQ_TOKEN}, {   3} },          
    { {       125}, { 186} }, // '}'   
    { {        10}, { 187} }, // '\x0a'
    { {         0}, {   0} },          
};

SR_ s_178[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -133} }, 
};

SR_ s_179[] =
{
    { { REQ_DEF}, {    4} },          
    { {     341}, {  188} }, // _block
    { {     283}, {  189} }, // ORNL  
    { {     274}, {  112} }, // BLOCK 
    { {       0}, { -129} },          
};

SR_ s_180[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -131} }, 
};

SR_ s_181[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -125} }, 
};

SR_ s_182[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -59} }, 
};

SR_ s_183[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -83} }, 
};

SR_ s_184[] =
{
    { { REQ_DEF}, {   2} },           
    { {     278}, { 190} }, // DECIMAL
    { {       0}, { -79} },           
};

SR_ s_185[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -34} }, 
};

SR_ s_186[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -135} }, 
};

SR_ s_187[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -132} }, 
};

SR_ s_188[] =
{
    { { DEF_RED}, {    1} }, 
    { {       0}, { -130} }, 
};

SR_ s_189[] =
{
    { { REQ_TOKEN}, {  26} },                   
    { {       342}, { 191} }, // _regex_list    
    { {       338}, { 181} }, // _regex         
    { {       337}, {  72} }, // _p_regex       
    { {       336}, {  73} }, // _simple_regex  
    { {       323}, {  74} }, // _combi_chars   
    { {        40}, {  75} }, // '('            
    { {       335}, {  76} }, // _characterclass
    { {       277}, {  77} }, // STRING         
    { {       278}, {  78} }, // DECIMAL        
    { {       279}, {  79} }, // ESCAPE_SEQUENCE
    { {       290}, {  80} }, // identifier     
    { {       284}, {  81} }, // CHAR           
    { {        46}, {  82} }, // '.'            
    { {        44}, {  83} }, // ','            
    { {        94}, {  84} }, // '^'            
    { {        36}, {  85} }, // '$'            
    { {        61}, {  86} }, // '='            
    { {        45}, {  87} }, // '-'            
    { {        39}, {  88} }, // '''            
    { {       334}, {  89} }, // _cc_set        
    { {       275}, {  39} }, // IDENTIFIER     
    { {       328}, {  90} }, // _cc_start      
    { {       329}, {  91} }, // _cc_negated    
    { {       280}, {  92} }, // CC_START       
    { {       281}, {  93} }, // CC_NEGATED     
    { {         0}, {   0} },                   
};

SR_ s_190[] =
{
    { { DEF_RED}, {   1} }, 
    { {       0}, { -78} }, 
};

SR_ s_191[] =
{
    { { REQ_DEF}, {    1} }, 
    { {       0}, { -124} }, 
};


// State array:
SR_ *s_state[] =
{
  s_0,  s_1,  s_2,  s_3,  s_4,  s_5,  s_6,  s_7,  s_8,  s_9,
  s_10,  s_11,  s_12,  s_13,  s_14,  s_15,  s_16,  s_17,  s_18,  s_19,
  s_20,  s_21,  s_22,  s_23,  s_24,  s_25,  s_26,  s_27,  s_28,  s_29,
  s_30,  s_31,  s_32,  s_33,  s_34,  s_35,  s_36,  s_37,  s_38,  s_39,
  s_40,  s_41,  s_42,  s_43,  s_44,  s_45,  s_46,  s_47,  s_48,  s_49,
  s_50,  s_51,  s_52,  s_53,  s_54,  s_55,  s_56,  s_57,  s_58,  s_59,
  s_60,  s_61,  s_62,  s_63,  s_64,  s_65,  s_66,  s_67,  s_68,  s_69,
  s_70,  s_71,  s_72,  s_73,  s_74,  s_75,  s_76,  s_77,  s_78,  s_79,
  s_80,  s_81,  s_82,  s_83,  s_84,  s_85,  s_86,  s_87,  s_88,  s_89,
  s_90,  s_91,  s_92,  s_93,  s_94,  s_95,  s_96,  s_97,  s_98,  s_99,
  s_100,  s_101,  s_102,  s_103,  s_104,  s_105,  s_106,  s_107,  s_108,  s_109,
  s_110,  s_111,  s_112,  s_113,  s_114,  s_115,  s_116,  s_117,  s_118,  s_119,
  s_120,  s_121,  s_122,  s_123,  s_124,  s_125,  s_126,  s_127,  s_128,  s_129,
  s_130,  s_131,  s_132,  s_133,  s_134,  s_135,  s_136,  s_137,  s_138,  s_139,
  s_140,  s_141,  s_142,  s_143,  s_144,  s_145,  s_146,  s_147,  s_148,  s_149,
  s_150,  s_151,  s_152,  s_153,  s_154,  s_155,  s_156,  s_157,  s_158,  s_159,
  s_160,  s_161,  s_162,  s_163,  s_164,  s_165,  s_166,  s_167,  s_168,  s_169,
  s_170,  s_171,  s_172,  s_173,  s_174,  s_175,  s_176,  s_177,  s_178,  s_179,
  s_180,  s_181,  s_182,  s_183,  s_184,  s_185,  s_186,  s_187,  s_188,  s_189,
  s_190,  s_191,
};

using SMap = std::map<int, char const *>;
using SMapVal = SMap::value_type;

SMapVal s_symArr[] =
{
    SMapVal(-2, "_UNDETERMINED_"),  // predefined symbols
    SMapVal(-1, "_EOF_"),
    SMapVal(256, "_error_"),

    SMapVal(257, "EXCL_START_CONDITION"),
    SMapVal(258, "INCL_START_CONDITION"),
    SMapVal(259, "SECTION_DELIMITER"),
    SMapVal(260, "BASECLASSHEADER"),
    SMapVal(261, "CLASSHEADER"),
    SMapVal(262, "CLASSNAME"),
    SMapVal(263, "DEBUG"),
    SMapVal(264, "DEBUG_STEPS"),
    SMapVal(265, "IMPLEMENTATIONHEADER"),
    SMapVal(266, "INPUTIMPLEMENTATION"),
    SMapVal(267, "INPUTINTERFACE"),
    SMapVal(268, "INTERACTIVE"),
    SMapVal(269, "LEXFUNCTIONNAME"),
    SMapVal(270, "LEXSOURCE"),
    SMapVal(271, "NAMESPACE"),
    SMapVal(272, "NOLINES"),
    SMapVal(273, "SKELETON_DIRECTORY"),
    SMapVal(274, "BLOCK"),
    SMapVal(275, "IDENTIFIER"),
    SMapVal(276, "EOF_PATTERN"),
    SMapVal(277, "STRING"),
    SMapVal(278, "DECIMAL"),
    SMapVal(279, "ESCAPE_SEQUENCE"),
    SMapVal(280, "CC_START"),
    SMapVal(281, "CC_NEGATED"),
    SMapVal(282, "PREDEFINED_CLASS"),
    SMapVal(283, "ORNL"),
    SMapVal(284, "CHAR"),
    SMapVal(285, "CC_PLUS"),
    SMapVal(286, "CC_MINUS"),
    SMapVal(287, "input"),
    SMapVal(288, "opt_directives"),
    SMapVal(289, "rules"),
    SMapVal(290, "identifier"),
    SMapVal(291, "_sc_name"),
    SMapVal(292, "_start_condition_type"),
    SMapVal(293, "_start_condition_names"),
    SMapVal(294, "_start_condition_directive"),
    SMapVal(295, "_name_def"),
    SMapVal(296, "_name_definition"),
    SMapVal(297, "_directive"),
    SMapVal(298, "option"),
    SMapVal(299, "_directive_line"),
    SMapVal(300, "_inputinterface"),
    SMapVal(301, "_inputimplementation"),
    SMapVal(302, "_classname"),
    SMapVal(303, "_lexfunctionname"),
    SMapVal(304, "_baseclassheader"),
    SMapVal(305, "_classheader"),
    SMapVal(306, "_implementationheader"),
    SMapVal(307, "_lexsource"),
    SMapVal(308, "_skeleton_directory"),
    SMapVal(309, "_namespace"),
    SMapVal(310, "_stringOrIdent"),
    SMapVal(311, "_opt_comma"),
    SMapVal(312, "_debugname"),
    SMapVal(313, "_debugnamelist"),
    SMapVal(314, "_m_debugnamelist"),
    SMapVal(315, "_opt_debugnamelist"),
    SMapVal(316, "_firststep"),
    SMapVal(317, "_opt_laststep"),
    SMapVal(318, "_m_debugsteps"),
    SMapVal(319, "_opt_steprange"),
    SMapVal(320, "_miniscanner_list"),
    SMapVal(321, "_miniscanner_specs"),
    SMapVal(322, "_miniscanner"),
    SMapVal(323, "_combi_chars"),
    SMapVal(324, "_decimal"),
    SMapVal(325, "_interval"),
    SMapVal(326, "_quantifier"),
    SMapVal(327, "_m_contents"),
    SMapVal(328, "_cc_start"),
    SMapVal(329, "_cc_negated"),
    SMapVal(330, "_cc_end"),
    SMapVal(331, "_cc_char"),
    SMapVal(332, "_cc_element"),
    SMapVal(333, "_cc_contents"),
    SMapVal(334, "_cc_set"),
    SMapVal(335, "_characterclass"),
    SMapVal(336, "_simple_regex"),
    SMapVal(337, "_p_regex"),
    SMapVal(338, "_regex"),
    SMapVal(339, "_optMs_regex"),
    SMapVal(340, "_optMs_regex_list"),
    SMapVal(341, "_block"),
    SMapVal(342, "_regex_list"),
    SMapVal(343, "_eof_pattern"),
    SMapVal(344, "_msBlock_rule_def"),
    SMapVal(345, "_msBlock_rule"),
    SMapVal(346, "_msBlock_rules"),
    SMapVal(347, "_msBlock"),
    SMapVal(348, "_rule_def"),
    SMapVal(349, "_rule"),
    SMapVal(350, "input_$"),
};

SMap s_symbol
(
    s_symArr, s_symArr + sizeof(s_symArr) / sizeof(SMapVal)
);

} // anonymous namespace ends



// If the parsing function call uses arguments, then provide an overloaded
// function.  The code below doesn't rely on parameters, so no arguments are
// required.  Furthermore, parse uses a function try block to allow us to do
// ACCEPT and ABORT from anywhere, even from within members called by actions,
// simply throwing the appropriate exceptions.

ParserBase::ParserBase()
:
    d_stackIdx_(-1),
    // $insert debuginit
    d_debug_(true),
    d_nErrors_(0),
    // $insert requiredtokens
    d_requiredTokens_(0),
    d_acceptedTokens_(d_requiredTokens_),
    d_token_(_UNDETERMINED_),
    d_nextToken_(_UNDETERMINED_)
{}

// $insert debugfunctions

std::ostringstream ParserBase::s_out_;

std::ostream &ParserBase::dflush_(std::ostream &out)
{
    std::ostringstream &s_out_ = dynamic_cast<std::ostringstream &>(out);

    std::cout << "    " << s_out_.str() << std::flush;
    s_out_.clear();
    s_out_.str("");
    return out;
}

std::string ParserBase::stype_(char const *pre, STYPE_ const &semVal, char const *post) const
{
    return "";
}
std::string ParserBase::symbol_(int value) const
{
    using namespace std;
    ostringstream ostr;
    SMap::const_iterator it = s_symbol.find(value);
    if (it != s_symbol.end())
        ostr << "`" << it->second << "'";
    else if (isprint(value))
        ostr << "`" << static_cast<char>(value) << "' (" << value << ")";
    else
        ostr << "'\\x" << setfill('0') << hex << setw(2) << value << "'";
    return ostr.str();
}


void ParserBase::clearin()
{
    d_token_ = d_nextToken_ = _UNDETERMINED_;
}

void ParserBase::push_(size_t state)
{
    if (static_cast<size_t>(d_stackIdx_ + 1) == d_stateStack_.size())
    {
        size_t newSize = d_stackIdx_ + STACK_EXPANSION;
        d_stateStack_.resize(newSize);
        d_valueStack_.resize(newSize);
    }
    ++d_stackIdx_;
    d_stateStack_[d_stackIdx_] = d_state_ = state;
    *(d_vsp_ = &d_valueStack_[d_stackIdx_]) = d_val_;
    // $insert debug
    if (d_debug_)
        s_out_ <<   "push(state " << state << stype_(", semantic TOS = ", d_val_, ")") << ')' << "\n" << dflush_;
}

void ParserBase::popToken_()
{
    d_token_ = d_nextToken_;

    d_val_ = d_nextVal_;
    d_nextVal_ = STYPE_();

    d_nextToken_ = _UNDETERMINED_;
}
     
void ParserBase::pushToken_(int token)
{
    d_nextToken_ = d_token_;
    d_nextVal_ = d_val_;
    d_token_ = token;
}
     
void ParserBase::pop_(size_t count)
{
    // $insert debug
    if (d_debug_)
        s_out_ <<  "pop(" << count << ") from stack having size " << (d_stackIdx_ + 1) << "\n" << dflush_;
    if (d_stackIdx_ < static_cast<int>(count))
    {
        // $insert debug
        if (d_debug_)
            s_out_ <<  "Terminating parse(): unrecoverable input error at token " << symbol_(d_token_) << "\n" << dflush_;
        ABORT();
    }

    d_stackIdx_ -= count;
    d_state_ = d_stateStack_[d_stackIdx_];
    d_vsp_ = &d_valueStack_[d_stackIdx_];
    // $insert debug
    if (d_debug_)
        s_out_ <<  "pop(): next state: " << d_state_ << ", token: " << symbol_(d_token_) ;
    // $insert debug
    if (d_debug_)
        s_out_ <<  stype_("semantic: ", d_val_) << "\n" << dflush_;
}

inline size_t ParserBase::top_() const
{
    return d_stateStack_[d_stackIdx_];
}

void Parser::executeAction(int production)
{
    if (d_token_ != _UNDETERMINED_)
        pushToken_(d_token_);     // save an already available token

                                    // save default non-nested block $$
    if (int size = s_productionInfo[production].d_size)
        d_val_ = d_vsp_[1 - size];

    // $insert debug
    if (d_debug_)
        s_out_ <<  "executeAction(): of rule " << production ;
    // $insert debug
    if (d_debug_)
        s_out_ <<   stype_(", semantic [TOS]: ", d_val_) << " ..." << "\n" << dflush_;
    switch (production)
    {
        // $insert actioncases
        
        case 2:
#line 68 "grammar"
        {
         d_val_ = d_scanner.matched();
         }
        break;

        case 3:
#line 2 "inc/directives"
        {
         
         }
        break;

        case 4:
#line 10 "inc/directives"
        {
         
         }
        break;

        case 5:
#line 16 "inc/directives"
        {
         
         }
        break;

        case 6:
#line 23 "inc/directives"
        {
         
         }
        break;

        case 7:
#line 28 "inc/directives"
        {
         
         }
        break;

        case 9:
#line 40 "inc/directives"
        {
         
         }
        break;

        case 10:
#line 47 "inc/directives"
        {
         
         }
        break;

        case 19:
#line 3 "inc/options"
        {
         
         }
        break;

        case 20:
#line 10 "inc/options"
        {
         
         }
        break;

        case 21:
#line 17 "inc/options"
        {
         
         }
        break;

        case 22:
#line 24 "inc/options"
        {
         
         }
        break;

        case 23:
#line 31 "inc/options"
        {
         
         }
        break;

        case 24:
#line 38 "inc/options"
        {
         
         }
        break;

        case 25:
#line 45 "inc/options"
        {
         
         }
        break;

        case 26:
#line 52 "inc/options"
        {
         
         }
        break;

        case 27:
#line 59 "inc/options"
        {
         
         }
        break;

        case 28:
#line 66 "inc/options"
        {
         
         }
        break;

        case 33:
#line 85 "inc/options"
        {
         
         }
        break;

        case 36:
#line 97 "inc/options"
        {
         
         }
        break;

        case 38:
#line 105 "inc/options"
        {
         
         }
        break;

        case 39:
#line 112 "inc/options"
        {
         
         }
        break;

        case 41:
#line 121 "inc/options"
        {
         
         }
        break;

        case 42:
#line 127 "inc/options"
        {
         
         }
        break;

        case 44:
#line 135 "inc/options"
        {
         
         }
        break;

        case 45:
#line 142 "inc/options"
        {
         
         }
        break;

        case 46:
#line 147 "inc/options"
        {
         
         }
        break;

        case 47:
#line 152 "inc/options"
        {
         
         }
        break;

        case 48:
#line 157 "inc/options"
        {
         
         }
        break;

        case 49:
#line 162 "inc/options"
        {
         
         }
        break;

        case 50:
#line 167 "inc/options"
        {
         
         }
        break;

        case 51:
#line 172 "inc/options"
        {
         
         }
        break;

        case 52:
#line 177 "inc/options"
        {
         
         }
        break;

        case 53:
#line 182 "inc/options"
        {
         
         }
        break;

        case 54:
#line 187 "inc/options"
        {
         
         }
        break;

        case 55:
#line 192 "inc/options"
        {
         
         }
        break;

        case 58:
#line 201 "inc/options"
        {
         
         }
        break;

        case 63:
#line 15 "inc/rules"
        {cout << "MINI\n";}
        break;

        case 76:
#line 48 "inc/rules"
        {
         
         }
        break;

        case 84:
#line 73 "inc/rules"
        {
         d_msg = "character class";
         }
        break;

        case 87:
#line 90 "inc/rules"
        {
         d_msg = "pattern or action block";
         }
        break;

        case 112:
#line 162 "inc/rules"
        { cout << "OR\n"; }
        break;

        case 114:
#line 167 "inc/rules"
        { cout << "QTY\n"; }
        break;

        case 115:
#line 170 "inc/rules"
        { cout << "CLASS\n"; }
        break;

        case 116:
#line 177 "inc/rules"
        {cout << "RE\n";}
        break;

        case 118:
#line 188 "inc/rules"
        {cout << "LA\n";}
        break;

        case 119:
#line 194 "inc/rules"
        {cout << "<MINI>RE\n";}
        break;

        case 121:
#line 206 "inc/rules"
        {cout << "ORNL\n";}
        break;

        case 123:
#line 213 "inc/rules"
        {
         block();
         }
        break;

        case 139:
#line 269 "inc/rules"
        { cout << "BLOCK\n"; }
        break;

    }
    // $insert debug
    if (d_debug_)
        s_out_ <<  "... action of rule " << production << " completed" ;
    // $insert debug
    if (d_debug_)
        s_out_ <<   stype_(", semantic: ", d_val_) << "\n" << dflush_;
}

inline void ParserBase::reduce_(PI_ const &pi)
{
    d_token_ = pi.d_nonTerm;
    pop_(pi.d_size);

    // $insert debug
    if (d_debug_)
        s_out_ <<  "reduce(): by rule " << (&pi - s_productionInfo) ;
    // $insert debug
    if (d_debug_)
        s_out_ <<  " to N-terminal " << symbol_(d_token_) << stype_(", semantic = ", d_val_) << "\n" << dflush_;
}

// If d_token_ is _UNDETERMINED_ then if d_nextToken_ is _UNDETERMINED_ another
// token is obtained from lex(). Then d_nextToken_ is assigned to d_token_.
void Parser::nextToken()
{
    if (d_token_ != _UNDETERMINED_)        // no need for a token: got one
        return;                             // already

    if (d_nextToken_ != _UNDETERMINED_)
    {
        popToken_();                       // consume pending token
        // $insert debug
        if (d_debug_)
            s_out_ <<  "nextToken(): popped " << symbol_(d_token_) << stype_(", semantic = ", d_val_) << "\n" << dflush_;
    }
    else
    {
        ++d_acceptedTokens_;               // accept another token (see
                                            // errorRecover())
        d_token_ = lex();
        if (d_token_ <= 0)
            d_token_ = _EOF_;
    }
    print();
    // $insert debug
    if (d_debug_)
        s_out_ <<  "nextToken(): using " << symbol_(d_token_) << stype_(", semantic = ", d_val_) << "\n" << dflush_;
}

// if the final transition is negative, then we should reduce by the rule
// given by its positive value. Note that the `recovery' parameter is only
// used with the --debug option
int Parser::lookup(bool recovery)
{
    // $insert threading
    SR_ *sr = s_state[d_state_];        // get the appropriate state-table
    int lastIdx = sr->d_lastIdx;        // sentinel-index in the SR_ array

    SR_ *lastElementPtr = sr + lastIdx;
    SR_ *elementPtr = sr + 1;            // start the search at s_xx[1]

    lastElementPtr->d_token = d_token_;// set search-token

    while (elementPtr->d_token != d_token_)
        ++elementPtr;

    if (elementPtr == lastElementPtr)   // reached the last element
    {
        if (elementPtr->d_action < 0)   // default reduction
        {
        // $insert debug
        if (d_debug_)
            s_out_ <<  "lookup(" << d_state_ << ", " << symbol_(d_token_) ;
        // $insert debug
        if (d_debug_)
            s_out_ <<  "): default reduction by rule " << -elementPtr->d_action << "\n" << dflush_;
            return elementPtr->d_action;                
        }
        // $insert debug
        if (d_debug_)
            s_out_ <<  "lookup(" << d_state_ << ", " << symbol_(d_token_) << "): Not " ;
        // $insert debug
        if (d_debug_)
            s_out_ <<  "found. " << (recovery ? "Continue" : "Start") << " error recovery."  << "\n" << dflush_;

        // No default reduction, so token not found, so error.
        throw UNEXPECTED_TOKEN_;
    }

    // not at the last element: inspect the nature of the action
    // (< 0: reduce, 0: ACCEPT, > 0: shift)

    int action = elementPtr->d_action;

// $insert debuglookup
    if (d_debug_)
    {
        s_out_ <<  "lookup(" << d_state_ << ", " << symbol_(d_token_);

        if (action < 0)             // a reduction is found
            s_out_ << "): reduce by rule " << -action;
        else if (action == 0)
            s_out_ <<  "): ACCEPT";
        else 
            s_out_ <<  "): shift " << action << " (" << symbol_(d_token_) << 
                        " processed)";

        s_out_ << "\n" << dflush_;
    }

    return action;
}

    // When an error has occurred, pop elements off the stack until the top
    // state has an error-item. If none is found, the default recovery
    // mode (which is to abort) is activated. 
    //
    // If EOF is encountered without being appropriate for the current state,
    // then the error recovery will fall back to the default recovery mode.
    // (i.e., parsing terminates)
void Parser::errorRecovery()
try
{
    if (d_acceptedTokens_ >= d_requiredTokens_)// only generate an error-
    {                                           // message if enough tokens 
        ++d_nErrors_;                          // were accepted. Otherwise
        error("Syntax error");                  // simply skip input

    }

    // $insert debug
    if (d_debug_)
        s_out_ <<  "errorRecovery(): " << d_nErrors_ << " error(s) so far. State = " << top_() << "\n" << dflush_;

    // get the error state
    while (not (s_state[top_()][0].d_type & ERR_ITEM))
    {
        // $insert debug
        if (d_debug_)
            s_out_ <<  "errorRecovery(): pop state " << top_() << "\n" << dflush_;
        pop_();
    }
    // $insert debug
    if (d_debug_)
        s_out_ <<  "errorRecovery(): state " << top_() << " is an ERROR state" << "\n" << dflush_;

    // In the error state, lookup a token allowing us to proceed.
    // Continuation may be possible following multiple reductions,
    // but eventuall a shift will be used, requiring the retrieval of
    // a terminal token. If a retrieved token doesn't match, the catch below 
    // will ensure the next token is requested in the while(true) block
    // implemented below:

    int lastToken = d_token_;                  // give the unexpected token a
                                                // chance to be processed
                                                // again.

    pushToken_(_error_);                       // specify _error_ as next token
    push_(lookup(true));                       // push the error state

    d_token_ = lastToken;                      // reactivate the unexpected
                                                // token (we're now in an
                                                // ERROR state).

    bool gotToken = true;                       // the next token is a terminal

    while (true)
    {
        try
        {
            if (s_state[d_state_]->d_type & REQ_TOKEN)
            {
                gotToken = d_token_ == _UNDETERMINED_;
                nextToken();                    // obtain next token
            }
            
            int action = lookup(true);

            if (action > 0)                 // push a new state
            {
                push_(action);
                popToken_();
                // $insert debug
                if (d_debug_)
                    s_out_ <<  "errorRecovery() SHIFT state " << action ;
                // $insert debug
                if (d_debug_)
                    s_out_ <<  ", continue with " << symbol_(d_token_) << "\n" << dflush_;

                if (gotToken)
                {
                    // $insert debug
                    if (d_debug_)
                        s_out_ <<  "errorRecovery() COMPLETED: next state " ;
                    // $insert debug
                    if (d_debug_)
                        s_out_ <<  action << ", no token yet" << "\n" << dflush_;

                    d_acceptedTokens_ = 0;
                    return;
                }
            }
            else if (action < 0)
            {
                // no actions executed on recovery but save an already 
                // available token:
                if (d_token_ != _UNDETERMINED_)
                    pushToken_(d_token_);
 
                                            // next token is the rule's LHS
                reduce_(s_productionInfo[-action]); 
                // $insert debug
                if (d_debug_)
                    s_out_ <<  "errorRecovery() REDUCE by rule " << -action ;
                // $insert debug
                if (d_debug_)
                    s_out_ <<  ", token = " << symbol_(d_token_) << "\n" << dflush_;
            }
            else
                ABORT();                    // abort when accepting during
                                            // error recovery
        }
        catch (...)
        {
            if (d_token_ == _EOF_)
                ABORT();                    // saw inappropriate _EOF_
                      
            popToken_();                   // failing token now skipped
        }
    }
}
catch (ErrorRecovery_)       // This is: DEFAULT_RECOVERY_MODE
{
    ABORT();
}

    // The parsing algorithm:
    // Initially, state 0 is pushed on the stack, and d_token_ as well as
    // d_nextToken_ are initialized to _UNDETERMINED_. 
    //
    // Then, in an eternal loop:
    //
    //  1. If a state does not have REQ_TOKEN no token is assigned to
    //     d_token_. If the state has REQ_TOKEN, nextToken() is called to
    //      determine d_nextToken_ and d_token_ is set to
    //     d_nextToken_. nextToken() will not call lex() unless d_nextToken_ is 
    //     _UNDETERMINED_. 
    //
    //  2. lookup() is called: 
    //     d_token_ is stored in the final element's d_token field of the
    //     state's SR_ array. 
    //
    //  3. The current token is looked up in the state's SR_ array
    //
    //  4. Depending on the result of the lookup() function the next state is
    //     shifted on the parser's stack, a reduction by some rule is applied,
    //     or the parsing function returns ACCEPT(). When a reduction is
    //     called for, any action that may have been defined for that
    //     reduction is executed.
    //
    //  5. An error occurs if d_token_ is not found, and the state has no
    //     default reduction. Error handling was described at the top of this
    //     file.

int Parser::parse()
try 
{
    // $insert debug
    if (d_debug_)
        s_out_ <<  "parse(): Parsing starts" << "\n" << dflush_;
    push_(0);                              // initial state
    clearin();                              // clear the tokens.

    while (true)
    {
        // $insert debug
        if (d_debug_)
            s_out_ <<  "==" << "\n" << dflush_;
        try
        {
            if (s_state[d_state_]->d_type & REQ_TOKEN)
                nextToken();                // obtain next token


            int action = lookup(false);     // lookup d_token_ in d_state_

            if (action > 0)                 // SHIFT: push a new state
            {
                push_(action);
                popToken_();               // token processed
            }
            else if (action < 0)            // REDUCE: execute and pop.
            {
                executeAction(-action);
                                            // next token is the rule's LHS
                reduce_(s_productionInfo[-action]); 
            }
            else 
                ACCEPT();
        }
        catch (ErrorRecovery_)
        {
            errorRecovery();
        }
    }
}
catch (Return_ retValue)
{
    // $insert debug
    if (d_debug_)
        s_out_ <<  "parse(): returns " << retValue << "\n" << dflush_;
    return retValue;
}

